package com.aura.springbook.service.impl;

import com.aura.springbook.mapper.BookCategoryMapper;
import com.aura.springbook.mapper.BookMapper;
import com.aura.springbook.mapper.UserMapper;
import com.aura.springbook.model.Book;
import com.aura.springbook.model.BookCategory;
import com.aura.springbook.model.User;
import com.aura.springbook.service.AdminService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * 管理员服务实现类
 * <p>
 * 实现管理员相关的业务操作，包括：
 * 1. 图书分类管理（增删改查）
 * 2. 图书信息管理（增删改查、库存调整）
 * 3. 用户管理（查询用户、角色调整）
 * <p>
 * 所有方法都通过控制器的权限检查后调用
 */
@Service
public class AdminServiceImpl implements AdminService {

    private static final Logger logger = LoggerFactory.getLogger(AdminServiceImpl.class);

    @Autowired
    private BookCategoryMapper bookCategoryMapper;

    @Autowired
    private BookMapper bookMapper;

    @Autowired
    private UserMapper userMapper;

    /**
     * 创建图书分类
     * <p>
     * 直接调用Mapper插入新的分类记录
     *
     * @param category 图书分类信息
     * @return 是否创建成功
     */
    @Override
    public boolean createCategory(BookCategory category) {
        logger.debug("开始创建图书分类, 分类名称: {}", category.getName());
        
        int result = bookCategoryMapper.insert(category);
        boolean success = result > 0;
        
        if (success) {
            logger.debug("创建图书分类成功, 分类ID: {}, 分类名称: {}", category.getId(), category.getName());
        } else {
            logger.warn("创建图书分类失败, 分类名称: {}", category.getName());
        }
        return success;
    }

    /**
     * 更新图书分类
     * <p>
     * 直接调用Mapper更新分类记录
     *
     * @param category 图书分类信息
     * @return 是否更新成功
     */
    @Override
    public boolean updateCategory(BookCategory category) {
        logger.debug("开始更新图书分类, 分类ID: {}", category.getId());
        
        int result = bookCategoryMapper.updateById(category);
        boolean success = result > 0;
        
        if (success) {
            logger.debug("更新图书分类成功, 分类ID: {}", category.getId());
        } else {
            logger.warn("更新图书分类失败, 分类ID: {}", category.getId());
        }
        return success;
    }

    /**
     * 删除图书分类
     * <p>
     * 删除前检查是否有图书属于这个分类，如果有则不能删除
     * 使用@Transactional注解保证数据一致性
     *
     * @param categoryId 分类ID
     * @return 是否删除成功
     */
    @Override
    @Transactional
    public boolean deleteCategory(Long categoryId) {
        logger.debug("开始删除图书分类, 分类ID: {}", categoryId);
        
        // 先检查是否有图书属于这个分类
        int bookCount = bookMapper.selectCountByCategoryId(categoryId);
        if (bookCount > 0) {
            // 如果有图书属于这个分类，不能删除
            logger.warn("删除图书分类失败, 该分类下还有图书, 分类ID: {}", categoryId);
            return false;
        }
        
        int result = bookCategoryMapper.deleteById(categoryId);
        boolean success = result > 0;
        
        if (success) {
            logger.debug("删除图书分类成功, 分类ID: {}", categoryId);
        } else {
            logger.warn("删除图书分类失败, 分类ID: {}", categoryId);
        }
        return success;
    }

    /**
     * 获取所有图书分类
     * <p>
     * 直接调用Mapper查询所有分类记录
     *
     * @return 图书分类列表
     */
    @Override
    public List<BookCategory> getAllCategories() {
        logger.debug("开始获取所有图书分类");
        
        List<BookCategory> categories = bookCategoryMapper.selectList(null);
        logger.debug("获取所有图书分类完成, 总数: {}", categories.size());
        return categories;
    }

    /**
     * 创建图书
     * <p>
     * 直接调用Mapper插入新的图书记录
     *
     * @param book 图书信息
     * @return 是否创建成功
     */
    @Override
    public boolean createBook(Book book) {
        logger.debug("开始创建图书, 图书标题: {}", book.getTitle());
        
        int result = bookMapper.insert(book);
        boolean success = result > 0;
        
        if (success) {
            logger.debug("创建图书成功, 图书ID: {}, 图书标题: {}", book.getId(), book.getTitle());
        } else {
            logger.warn("创建图书失败, 图书标题: {}", book.getTitle());
        }
        return success;
    }

    /**
     * 更新图书
     * <p>
     * 直接调用Mapper更新图书记录
     *
     * @param book 图书信息
     * @return 是否更新成功
     */
    @Override
    public boolean updateBook(Book book) {
        logger.debug("开始更新图书, 图书ID: {}", book.getId());
        
        int result = bookMapper.updateById(book);
        boolean success = result > 0;
        
        if (success) {
            logger.debug("更新图书成功, 图书ID: {}", book.getId());
        } else {
            logger.warn("更新图书失败, 图书ID: {}", book.getId());
        }
        return success;
    }

    /**
     * 删除图书
     * <p>
     * 删除前检查是否有未归还的借阅记录，如果有则不能删除
     *
     * @param bookId 图书ID
     * @return 是否删除成功
     */
    @Override
    public boolean deleteBook(Long bookId) {
        logger.debug("开始删除图书, 图书ID: {}", bookId);
        
        // 检查是否有未归还的借阅记录
        int borrowCount = bookMapper.selectUnreturnedCountByBookId(bookId);
        if (borrowCount > 0) {
            // 如果有未归还的借阅记录，不能删除
            logger.warn("删除图书失败, 还有未归还的借阅记录, 图书ID: {}", bookId);
            return false;
        }
        
        int result = bookMapper.deleteById(bookId);
        boolean success = result > 0;
        
        if (success) {
            logger.debug("删除图书成功, 图书ID: {}", bookId);
        } else {
            logger.warn("删除图书失败, 图书ID: {}", bookId);
        }
        return success;
    }

    /**
     * 更新图书库存
     * <p>
     * 先查询图书信息，然后更新库存字段
     *
     * @param bookId 图书ID
     * @param stock  库存数量（不能为负数）
     * @return 是否更新成功
     */
    @Override
    public boolean updateBookStock(Long bookId, int stock) {
        logger.debug("开始更新图书库存, 图书ID: {}, 新库存: {}", bookId, stock);
        
        Book book = bookMapper.selectById(bookId);
        if (book != null) {
            book.setStock(stock);
            int result = bookMapper.updateById(book);
            boolean success = result > 0;
            
            if (success) {
                logger.debug("更新图书库存成功, 图书ID: {}, 新库存: {}", bookId, stock);
            } else {
                logger.warn("更新图书库存失败, 图书ID: {}", bookId);
            }
            return success;
        }
        
        logger.warn("更新图书库存失败, 图书不存在, 图书ID: {}", bookId);
        return false;
    }

    /**
     * 获取所有用户
     * <p>
     * 直接调用Mapper查询所有用户记录
     *
     * @return 用户列表
     */
    @Override
    public List<User> getAllUsers() {
        logger.debug("开始获取所有用户");
        
        List<User> users = userMapper.selectList(null);
        logger.debug("获取所有用户完成, 总数: {}", users.size());
        return users;
    }

    /**
     * 更新用户角色
     * <p>
     * 先查询用户信息，然后更新角色字段
     *
     * @param userId 用户ID
     * @param role   角色（USER/ADMIN）
     * @return 是否更新成功
     */
    @Override
    public boolean updateUserRole(Long userId, String role) {
        logger.debug("开始更新用户角色, 用户ID: {}, 新角色: {}", userId, role);
        
        User user = userMapper.selectById(userId);
        if (user != null) {
            user.setRole(role);
            int result = userMapper.updateById(user);
            boolean success = result > 0;
            
            if (success) {
                logger.debug("更新用户角色成功, 用户ID: {}, 新角色: {}", userId, role);
            } else {
                logger.warn("更新用户角色失败, 用户ID: {}", userId);
            }
            return success;
        }
        
        logger.warn("更新用户角色失败, 用户不存在, 用户ID: {}", userId);
        return false;
    }
}